import cache from '../../api/cache'
import {
  calculateBazi
} from '../../utils/calendar.js';
import {
  request
} from "../../requests/post.js";

const app = getApp();

Page({
  data: {
    displayNumber: 0,
    targetNumber: 88, // 指定要显示的数字
    rollingInterval: null,
    rollingSpeed: 50, // 滚动速度，单位为毫秒
    scoreTimes: 10,
    birthday: '',
    showResult: false,
    score: 0,
    xingzuo: '',
    xzSrc: '',
    comment: '',
    // comments: {
    //   best: ["天选之人！", "✨ 完美人生开启者 ✨", "宇宙的宠儿"],
    //   good: ["好运相伴", "潜力无限", "未来可期"],
    //   normal: ["平稳是福", "中庸之道", "脚踏实地"],
    //   bad: ["逆袭预备役", "梅花香自苦寒来", "蓄势待发"]
    // },

    comments: {
      excellent: {
        range: [90, 100],
        texts: [
          "春风得意马蹄疾，锦绣前程自可期 🌸",
          "天选之人的光芒，照亮未来的每一步 ✨",
          "星辰大海的入场券已送达 🌌",
          "命运齿轮开始转动，请保持期待 ⚙️",
          "人生开卷即满分，保持热爱赴山海 📖",
          "吉星高照，顺势而为正当时 🌠",
          "鲲鹏展翅九万里，长空无涯任搏击 🦅",
          "天时地利皆俱备，静待人和好时机 🌏",
          "犹如凤凰浴火生，终将展翅傲九天 🔥",
          "祥云环绕福星照，心想事成路路通 ☁️"
        ]
      },
      great: {
        range: [75, 90],
        texts: [
          "心有猛虎细嗅蔷薇，刚柔并济自天成 🌺",
          "人生进度条加载顺利，请继续前行 📈",
          "璞玉经琢即成器，静待绽放时刻 🪨",
          "前路虽有迷雾，明灯已为君亮 🏮",
          "破茧成蝶进行时，静候华丽蜕变 🦋",
          "日积跬步终致远，江河不择细流成 🌊",
          "手持人生上上签，从容应对皆风景 🎐",
          "厚积薄发正当时，静待春雷第一声 🌩️",
          "运势如虹贯长空，稳扎稳打定成功 🌈",
          "智慧锦囊已备妥，且行且歌莫踌躇 🎶"
        ]
      },
      good: {
        range: [60, 75],
        texts: [
          "平凡中见真章，静水流深显力量 💧",
          "人生剧本渐入佳境，请保持期待 📜",
          "蓄力期的蛰伏，是为更好的绽放 🌱",
          "种子已遇沃土，静待破土而出 🌻",
          "磨刀不误砍柴工，厚积薄发会有时 ⏳",
          "人生如棋局局新，落子无悔即智慧 🎲",
          "逆水行舟显毅力，柳暗花明在前方 🚣",
          "璞玉稍经雕琢，必显夺目光华 💎",
          "运势如弦上之箭，引而不发跃如也 🏹",
          "天行健君子自强，地势坤厚德载物 ☯️"
        ]
      },
      normal: {
        range: [40, 60],
        texts: [
          "逆风翻盘预备役，人生转折正当时 🔄",
          "梅花香自苦寒来，宝剑锋从磨砺出 ❄️",
          "低谷恰是登高始，且看明朝展宏图 🏔️",
          "命运留白处，正是挥毫好时机 🖌️",
          "蛰伏期的沉淀，终将化作破晓光 🌅",
          "青松不惧雪压顶，来年依旧笑春风 🌲",
          "人生马拉松，耐力比爆发更重要 🏃",
          "璞玉待雕琢，良工已在途 🛠️",
          "运势如弹簧，此刻压缩为迸发 🌀",
          "竹杖芒鞋轻胜马，谁怕？一蓑烟雨任平生 🎋"
        ]
      }
    },

    welFlag: true,
    photo_url: app.globalData.baseUrl + "/wx/TX.jpg",
    user: {},
    arraySex: ['女', '男'],
    user: {
      userName: null,
      sex: null,
      age: null,
      telephone: null,
      upAge: null,
      downAge: null,
      scoreAuthorize: null
    },
    listShowFlag: false,
    account: '',
    userInfo: null,
    constellation: '',
    constellationDesc: '',
    titleActive: false
  },

  // onLoad() {
  //   const defaultDate = this.getDefaultDate();
  //   this.setData({ birthday: defaultDate });
  // },
  onTitleTouch() {
    this.setData({
      titleActive: !this.data.titleActive
    })
  },
  onLoad: function (options) {
    var user = cache.getOp(app.globalData.userCacheKey)

    console.info(JSON.stringify(user))
    // if (user != null && user.scoreAuthorize == '1') {
    if (user != null) {
      this.setData({
        'listShowFlag': false,
        'welFlag': false
        // 'user': user
      })
      const defaultDate = this.getDefaultDate();
      this.setData({
        birthday: defaultDate
      });
      // 获取最新的次数数据
      let that = this
      request({
        url: '/xq/getTimes',
        id: user.id
      }).then(result => {
        if (result.data.errorCode === 200) {
          that.setData({
            "user": result.data.data
          })
        } else {
          wx.showToast({
            title: result.data.msg,
            icon: 'none',
            duration: 2000,
          })
          return
        }
      }).catch(err => {
        console.error(err)
        return
      })

    } else {

    }
  },

  wxLogin() {
    var timestamp = Date.now();
    timestamp = Math.floor(timestamp / 1000).toString();
    var nickName = "番薯用户" + timestamp
    console.log("nickname - " + nickName)

    if (nickName !== "" && nickName !== null) {
      console.log("nickname - 11")
      var that = this
      wx.login({
        success(res) {
          if (res.code) {
            request({
              url: '/xq/login',
              code: res.code,
              nickName: nickName,
              type: 'LIFE'
            }).then(result => {
              if (result.data.errorCode == 200) {
                cache.setOp(app.globalData.userCacheKey, result.data.data)
                // cache.setOp(app.globalData.tokenKey, result.data.data["token"])
                // app.globalData.token = result.data.data["token"]
                app.globalData.key = result.data.data["key"]
                that.setData({
                  user: result.data.data,
                  hasUserInfo: true,
                })
                // 跳转到指标页
                wx.hideLoading()
                that.setData({
                  'listShowFlag': true
                })
                that.setData({
                  welFlag: false
                })

                const defaultDate = that.getDefaultDate();
                that.setData({
                  birthday: defaultDate
                });
                //   if (result.data.data.scoreAuthorize == "1") {
                //     // wx.redirectTo({
                //     //   url: 'birthday'
                //     // })
                //     that.setData({
                //       welFlag: false
                //     })

                //     const defaultDate = that.getDefaultDate();
                //     that.setData({
                //       birthday: defaultDate
                //     });
                //   }
                // } else {
                //   wx.hideLoading()
                //   that.setData({
                //     "iosDialog2": true
                //   })
                //   console.log('服务器异常')
              }
            }, err => {
              //调用服务端登录接口失败
              wx.hideLoading()
              that.setData({
                "iosDialog2": true
              })
            })
          }
        }
      })
    } else {
      wx.showToast({
        title: '昵称不能为空',
        icon: 'none',
        duration: 2000,
      })
    }

  },

  getDefaultDate() {
    const date = new Date();
    return `${date.getFullYear()}-${date.getMonth()+1}-${date.getDate()}`;
  },

  dateChange(e) {
    this.setData({
      birthday: e.detail.value,
      showResult: false
    });
    this.calculateConstellation();
  },

  calculateConstellation() {
    const date = new Date(this.data.birthday);
    const month = date.getMonth() + 1;
    const day = date.getDate();
    let constellation = '';
    let constellationDesc = '';
    let xzSrc = '';

    if ((month === 3 && day >= 21) || (month === 4 && day <= 19)) {
      constellation = '白羊座';
      xzSrc = "../../icons/白羊座.png";
      constellationDesc = '白羊座的人热情冲动、爱冒险、慷慨、天不怕地不怕而且一旦下定决心，不到黄河心不死，排除万难也要达到目的。';
    } else if ((month === 4 && day >= 20) || (month === 5 && day <= 20)) {
      constellation = '金牛座';
      xzSrc = "../../icons/金牛座.png";
      constellationDesc = '金牛座的人比较保守，属于慢热型的性格，不会急躁鲁莽，总是一步步稳健地进取。他们对于生活品质有一定的追求。';
    } else if ((month === 5 && day >= 21) || (month === 6 && day <= 21)) {
      constellation = '双子座';
      xzSrc = "../../icons/双子座.png";
      constellationDesc = '双子座的人往往喜好新鲜事物，他们有着小聪明，但做事常常不太专一。他们的适应能力很强，对环境变化能快速做出反应。';
    } else if ((month === 6 && day >= 22) || (month === 7 && day <= 22)) {
      constellation = '巨蟹座';
      xzSrc = "../../icons/巨蟹座.png";
      constellationDesc = '巨蟹座的人充满爱心，重视家庭，他们情感细腻，有很强的保护欲和同情心，但有时也会比较敏感和情绪化。';
    } else if ((month === 7 && day >= 23) || (month === 8 && day <= 22)) {
      constellation = '狮子座';
      xzSrc = "../../icons/狮子座.png";
      constellationDesc = '狮子座的人自信满满，具有领导能力，他们热情开朗，喜欢成为众人瞩目的焦点，对朋友真诚大方，但有时会有点自负。';
    } else if ((month === 8 && day >= 23) || (month === 9 && day <= 22)) {
      constellation = '处女座';
      xzSrc = "../../icons/处女座.png";
      constellationDesc = '处女座的人追求完美，做事认真负责，注重细节，他们勤奋努力，有条理，但有时会过于挑剔和苛求自己与他人。';
    } else if ((month === 9 && day >= 23) || (month === 10 && day <= 23)) {
      constellation = '天秤座';
      xzSrc = "../../icons/天秤座.png";
      constellationDesc = '天秤座的人优雅迷人，善于社交，他们追求平衡和公正，注重人际关系的和谐，但有时会在做决策时犹豫不决。';
    } else if ((month === 10 && day >= 24) || (month === 11 && day <= 22)) {
      constellation = '天蝎座';
      xzSrc = "../../icons/天蝎座.png";
      constellationDesc = '天蝎座的人神秘莫测，有着强烈的好奇心和洞察力，他们意志坚定，对目标执着追求，但有时会比较多疑和记仇。';
    } else if ((month === 11 && day >= 23) || (month === 12 && day <= 21)) {
      constellation = '射手座';
      xzSrc = "../../icons/射手座.png";
      constellationDesc = '射手座的人乐观开朗，热爱自由，他们喜欢冒险和探索新事物，为人坦率真诚，但有时会比较粗心和缺乏耐心。';
    } else if ((month === 12 && day >= 22) || (month === 1 && day <= 19)) {
      constellation = '摩羯座';
      xzSrc = "../../icons/摩羯座.png";
      constellationDesc = '摩羯座的人踏实稳重，有强烈的责任感，他们目标明确，为了实现目标愿意付出努力，但有时会显得过于严肃和冷漠。';
    } else if ((month === 1 && day >= 20) || (month === 2 && day <= 18)) {
      constellation = '水瓶座';
      xzSrc = "../../icons/水瓶座.png";
      constellationDesc = '水瓶座的人思维独特，富有创新精神，他们追求自由和平等，不喜欢受到束缚，但有时会让人觉得有些冷漠和难以捉摸。';
    } else if ((month === 2 && day >= 19) || (month === 3 && day <= 20)) {
      constellation = '双鱼座';
      xzSrc = "../../icons/双鱼座.png";
      constellationDesc = '双鱼座的人温柔善良，富有同情心，他们充满幻想，情感丰富，但有时会过于敏感和优柔寡断。';
    }

    this.setData({
      constellation: constellation,
      constellationDesc: constellationDesc,
      xzSrc: xzSrc
    });
  },

  getComment(score) {
    // 先筛选符合条件的等级
    const validLevels = Object.keys(this.data.comments)
      .filter(level => {
        const [min, max] = this.data.comments[level].range;
        return score >= min && score < max;
      });

    // 随机选择一个符合的等级（当分数处于交界区域时）
    const selectedLevel = validLevels[Math.floor(Math.random() * validLevels.length)];

    // 从该等级的评语中随机选择
    const texts = this.data.comments[selectedLevel].texts;
    let selectedIndex = Math.floor(Math.random() * texts.length);

    // 避免连续出现相同评语
    if (this.data.lastComment && texts.length > 1) {
      while (texts[selectedIndex] === this.data.lastComment) {
        selectedIndex = (selectedIndex + 1) % texts.length;
      }
    }

    this.setData({
      lastComment: texts[selectedIndex]
    });
    return texts[selectedIndex];
  },

  getComment1(score) {
    const {
      comments
    } = this.data;
    if (score >= 90) return comments.best[Math.floor(Math.random() * 3)];
    if (score >= 75) return comments.good[Math.floor(Math.random() * 3)];
    if (score >= 60) return comments.normal[Math.floor(Math.random() * 3)];
    return comments.bad[Math.floor(Math.random() * 3)];
  },

  // 完全实现的评分算法（安全范围+合理分布）
  calculateScore0() {

    const birthday = this.data.birthday;
    console.info(birthday)
    // 参数校验
    // if (!/^\d{4}-\d{1}-\d{2}$/.test(birthday)) {
    //   throw new Error('日期格式无效');
    // }

    // 1. 基础分计算（40-60分）
    const cleanStr = birthday.replace(/-/g, '');
    const digitSum = [...cleanStr].reduce((acc, c) => acc + parseInt(c), 0);
    const baseScore = 40 + Math.round(digitSum % 21); // 确保40-60之间

    // 2. 幸运因子计算（0-25分）
    const date = new Date(birthday);

    // 2.1 季节加成（0-8分）
    const seasonWeights = [
      2, 2, 3, // 春季（2-4月）
      5, 5, 4, // 夏季（5-7月）
      3, 3, 2, // 秋季（8-10月）
      1, 1, 2 // 冬季（11-1月）
    ];
    const seasonBonus = seasonWeights[date.getMonth()];

    // 2.2 质数日加成（0-5分）
    const day = date.getDate();
    const isPrimeDay = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31].includes(day);
    const primeBonus = isPrimeDay ? 5 : 0;

    // 2.3 心理学随机因子（0-12分）
    const randFactor = Math.floor(
      Math.sin(digitSum) * 1000 % 13 // 稳定的伪随机
    );

    // 3. 动态平衡机制
    const dynamicBalance = Date.now() % 7; // 引入时间变量

    // 总分计算
    let total = baseScore +
      seasonBonus +
      primeBonus +
      randFactor +
      dynamicBalance;

    // 安全范围控制（40-99）
    this.setResult(Math.min(99, Math.max(40, total)));
  },

  calculateScore() {
    var times = this.data.user.scoreTimes - 1;
    const name = this.data.user.userName;
    const flag = this.data.user.scoreAuthorize;
    console.info(flag)
    wx.showLoading({
      title: '评测中'
    })
    if (flag == '0' || flag === null) {
      wx.showModal({
        title: '使用次数提醒',
        content: `${name} - 当前剩余使用次数仅剩${times}次,请联系微信z_zqianmo获得永久授权`,
        confirmText: '知道了',
        showCancel: false
      })

      if (times == 0) {
        wx.hideLoading()
        return;
      }

      let that = this
      request({
        url: '/xq/eval_score',
        id: that.data.user.id
      }).then(result => {
        if (result.data.errorCode === 200) {
          that.setData({
            "user.scoreTimes": times
          })
        } else {
          wx.showToast({
            title: result.data.msg,
            icon: 'none',
            duration: 2000,
          })
          return
        }
      }).catch(err => {
        console.error(err)
        return
      })
    }
    // 先清空之前的数据
    this.setData({
      constellation: '',
      constellationDesc: '',
      comment: '',
      xzSrc:''
    })


    this.calculateConstellation();
    const birthday = this.data.birthday;
    const [year, month, day] = birthday.split('-').map(Number);

    // 核心算法优化
    const scoreComponents = {
      lifeNumber: this.calcLifeNumber(year, month, day), // 生命灵数（1-9）
      zodiacBonus: this.getZodiacBonus(month, day), // 星座加成
      generationFactor: this.getGenerationFactor(year), // 时代系数
      ageStage: this.getAgeStage(year), // 年龄阶段
      specialDate: this.checkSpecialDate(month, day) // 特殊日期
    };

    console.info(Math.sin(year + month + day).toString().substr(5, 2) * 1);
    // 分数合成公式
    // let score = Math.min(
    //   (scoreComponents.lifeNumber * 12) + 
    //   (scoreComponents.zodiacBonus * 8) +
    //   (scoreComponents.generationFactor * 5) +
    //   (scoreComponents.ageStage * 3) +
    //   (scoreComponents.specialDate * 15) +
    //   Math.sin(year + month + day).toString().substr(5,2)*1, // 随机波动
    //   99
    // );
    let score = Math.min(
      // 1~9分
      (scoreComponents.lifeNumber * 2) +
      // 6~9
      (scoreComponents.zodiacBonus * 1) +
      // 19 ~ 20
      (scoreComponents.generationFactor * 0.5) +
      // 15~ 30
      (scoreComponents.ageStage * 1) +
      // 0 10
      (scoreComponents.specialDate * 1) +
      30,
      // Math.sin(year + month + day).toString().substr(5,2)*1, // 随机波动
      99
    );

    // 保底机制和年龄加成 保底68分
    score = Math.max(68, score + this.getAgeWisdom(year));
    this.setResult(score);

    wx.hideLoading();
  },

  // 新增辅助方法
  calcLifeNumber(y, m, d) {
    const sum = String(y + m + d).split('').reduce((a, b) => a + Number(b), 0);
    return sum > 9 ? this.calcLifeNumber(sum, 0, 0) : sum;
  },

  getZodiacBonus(m, d) {
    const zodiacs = [{
        range: [3, 21, 4, 19],
        value: 8,
        text: "白羊"
      }, // 白羊
      {
        range: [4, 20, 5, 20],
        value: 7,
        text: "金牛"
      }, // 金牛
      {
        range: [5, 21, 6, 21],
        value: 9,
        text: "双子"
      }, // 双子
      {
        range: [6, 22, 7, 22],
        value: 6,
        text: "巨蟹"
      }, // 巨蟹
      {
        range: [7, 23, 8, 22],
        value: 10,
        text: "狮子"
      }, // 狮子
      {
        range: [8, 23, 9, 22],
        value: 7,
        text: "处女"
      }, // 处女
      {
        range: [9, 23, 10, 23],
        value: 8,
        text: "天秤"
      }, // 天秤
      {
        range: [10, 24, 11, 22],
        value: 9,
        text: "天蝎"
      }, // 天蝎
      {
        range: [11, 23, 12, 21],
        value: 7,
        text: "射手"
      }, // 射手
      {
        range: [12, 22, 1, 19],
        value: 8,
        text: "摩羯"
      }, // 摩羯
      {
        range: [1, 20, 2, 18],
        value: 6,
        text: "水瓶"
      }, // 水瓶
      {
        range: [2, 19, 3, 20],
        value: 9,
        text: "双鱼"
      } // 双鱼
    ];
    const current = zodiacs.find(z =>
      (m === z.range[0] && d >= z.range[1]) ||
      (m === z.range[2] && d <= z.range[3])
    );

    this.setData({
      "xingzuo": current.text
    })

    return current ? current.value : 7;
  },

  getAgeStage(y) {
    const age = new Date().getFullYear() - y;
    if (age < 18) return 15; // 成长潜力期
    if (age < 30) return 20; // 黄金上升期
    if (age < 50) return 25; // 人生巅峰期
    return 30; // 智慧传承期
  },

  getGenerationFactor(y) {
    return y / 100;
  },

  checkSpecialDate(m, d) {
    // 常见幸运日判断
    const luckyDates = [
      [1, 1],
      [2, 2],
      [3, 3],
      [4, 4],
      [5, 5],
      [6, 6],
      [7, 7],
      [8, 8],
      [9, 9],
      [10, 10],
      [11, 11],
      [12, 12],
      [7, 17],
      [8, 18],
      [9, 19]
    ];
    return luckyDates.some(([mm, dd]) => m === mm && d === dd) ? 10 : 0;
  },

  getAgeWisdom(y) {
    const age = new Date().getFullYear() - y;
    return Math.min(age * 0.3, 10); // 年龄带来的智慧加成
  },

  setResult(score) {
    const levels = [{
        min: 90,
        comments: ["天命所归", "星辰眷顾者", "传奇缔造者"],
        emoji: "🌟"
      },
      {
        min: 80,
        comments: ["鸿运当头", "时来运转", "乘风破浪"],
        emoji: "🚀"
      },
      {
        min: 70,
        comments: ["稳中求进", "厚积薄发", "静待花开"],
        emoji: "🌱"
      },
      {
        min: 50,
        comments: ["逆光前行", "破茧成蝶", "曙光在望"],
        emoji: "🦋"
      }
    ];

    const {
      comments,
      emoji
    } = levels.find(l => score >= l.min);

    const s = Math.round(score);
    const c = this.getComment(score);
    this.startRolling(s, c);
    this.setData({
      // score: s,
      // targetNumber: s,
      showResult: true
      // comment: `${emoji} ${comments[Math.floor(Math.random()*3)]}`
      // comment: this.getComment(score)
    });

  },

  startRolling(score, comment) {
    // 清除之前的滚动定时器
    if (this.data.rollingInterval) {
      clearInterval(this.data.rollingInterval);
    }
    // 开始滚动
    this.data.rollingInterval = setInterval(() => {
      // 生成随机数字
      const randomNumber = Math.floor(Math.random() * 100);
      this.setData({
        displayNumber: randomNumber
      });
    }, this.data.rollingSpeed);

    this.setData({
      targetNumber: score
    });

    // this.blockFunction(2500)
    // clearInterval(this.data.rollingInterval);
    // this.setData({
    //   displayNumber: this.data.targetNumber
    // });
    // 停止滚动并显示指定数字
    setTimeout(() => {
      clearInterval(this.data.rollingInterval);
      this.setData({
        displayNumber: this.data.targetNumber,
        comment: comment
      });
    }, 2500); 
  }



})